<html>
	<head>
		<meta charset="utf-8"></meta>
		<title>BSet</title>
		<link href="./style.css" rel="stylesheet" type="text/css"/>
	</head>
	<body>
		<div class="class" name="BSet">
			<h1>BSet</h1>
			<p>继承自<a href="BThing.html">BThing</a></p>
			<p id="resume">BSet是有序容器类，常称为集合类，使用连续内存进行元素管理。<a href="#desc">详细</a></p><h2>public</h2>
			<table id="public">
				<tr><td align="right">inline </td><td><a href="#BSet() :)">BSet</a>() : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BSet(const UT*, int size) :)">BSet</a>(const UT* data, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BSet(const T*, int size) :)">BSet</a>(const T* data, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BSet(const BSet<UT>& other) :)">BSet</a>(const BSet&lt;UT&gt;&amp; other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BSet(const BSet& other) :)">BSet</a>(const BSet&amp; other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#~BSet()">~BSet</a>();</td></tr>
				<tr><td align="right">inline int </td><td><a href="#size() const">size</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#capacity() const">capacity</a>() const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#empty() const">empty</a>() const;</td></tr>
				<tr><td align="right">inline void </td><td><a href="#reset()">reset</a>();</td></tr>
				<tr><td align="right">inline void </td><td><a href="#clear()">clear</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#relax()">relax</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#reserve(int)">reserve</a>(int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#check(int) const">check</a>(int index) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#contain(const UT&) const">contain</a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#contain(const T&) const">contain</a>(const T&amp; value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(const UT&) const">find</a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(const T&) const">find</a>(const T&amp; value) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#first()">first</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#first() const">first</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#middle()">middle</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#middle() const">middle</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#last()">last</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#last() const">last</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#min()">min</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#min() const">min</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#max()">max</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#max() const">max</a>() const;</td></tr>
				<tr><td align="right">inline T* </td><td><a href="#data()">data</a>();</td></tr>
				<tr><td align="right">inline const T* </td><td><a href="#data() const">data</a>() const;</td></tr>
				<tr><td align="right">inline T* </td><td><a href="#data(int)">data</a>(int index);</td></tr>
				<tr><td align="right">inline const T* </td><td><a href="#data(int) const">data</a>(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#at(int)">at</a>(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#at(int) const">at</a>(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#def()">def</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#def() const">def</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const UT&)">insert</a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const T&)">insert</a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const UT*, int)">insert</a>(const UT* data, int size);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const T*, int)">insert</a>(const T* data, int size);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const BSet<UT>&)">insert</a>(const BSet&lt;UT&gt;&amp; other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#insert(const BSet&)">insert</a>(const BSet&amp; other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(int,int)">remove</a>(int pos, int count = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const UT&)">remove</a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const T&)">remove</a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#remove(const UT*, int)">remove</a>(const UT* data, int size);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#remove(const T*, int)">remove</a>(const T* data, int size);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#remove(const BSet<UTk>&)">remove</a>(const BSet&lt;UTk&gt;&amp; other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#remove(const BSet&)">remove</a>(const BSet&amp; other);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#operator()(int)">operator</a>()(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#operator()(int) const">operator</a>()(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#operator[](int)">operator[]</a>(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#operator[](int) const">operator[]</a>(int index) const;</td></tr>
				<tr><td align="right">inline const BSet&amp; </td><td><a href="#operator = (const BSet<UT>&)">operator = </a>(const BSet&lt;UT&gt;&amp; other);</td></tr>
				<tr><td align="right">inline const BSet&amp; </td><td><a href="#operator = (const BSet&)">operator = </a>(const BSet&amp; other);</td></tr>
				<tr><td align="right">inline BSet&amp; </td><td><a href="#operator << (const UT&)">operator &lt;&lt; </a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline BSet&amp; </td><td><a href="#operator << (const T&)">operator &lt;&lt; </a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline BSet&amp; </td><td><a href="#operator << (const BSet<UT>&)">operator &lt;&lt; </a>(const BSet&lt;UT&gt;&amp; other);</td></tr>
				<tr><td align="right">inline BSet&amp; </td><td><a href="#operator << (const BSet&)">operator &lt;&lt; </a>(const BSet&amp; other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#operator < (const UT&) const">operator &lt; </a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#operator <= (const UT&) const">operator &lt;= </a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#operator > (const UT&) const">operator &gt; </a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#operator >= (const UT&) const">operator &gt;= </a>(const UT&amp; value) const;</td></tr>
			</table>
			<div id="desc">
				<h2>详细介绍：</h2>
				<p> BSet是有序容器类，常称为集合类，使用连续内存进行元素管理。所以可以用索引的方式进行元素的访问。此容器中的元素不可以重复存在。以下为使用示例：
					<br/>
				</p><pre> BSet<int/> iset;
	iset.insert(123);
	iset.insert(456);
	iset.insert(789);
	iset.insert(123);
	for (int i = 0; i &lt; iset.size(); i++)
	{
		printf("%d : %d\n", i, iset[i]);
	}
			
				</pre><p>由于集合使用了多快速的排序方法其插入的效率比较高，且查找速度也比较快。</p>
			</div>
			<h2 id="docs">成员文档：</h2>
			<div id="BSet() :)">
				<h3>inline BSet() : _def();</h3>
				<p>构造一个空的集合。</p>
			</div>
			<div id="BSet(const UT*, int size) :)">
				<h3>inline BSet(const UT* data, int size) : _def();</h3>
				<p>构造一个集合，并添加若干个元素，data指示用于赋值的数据位置，size表示数据数量。</p>
			</div>
			<div id="BSet(const T*, int size) :)">
				<h3>inline BSet(const T* data, int size) : _def();</h3>
				<p>构造一个集合，并添加若干个元素，data指示用于赋值的数据位置，size表示数据数量。</p>
			</div>
			<div id="BSet(const BSet<UT>& other) :)">
				<h3>inline BSet(const BSet&lt;UT&gt;&amp; other) : _def();</h3>
				<p>构造一个集合，并添加other中的所有元素。</p>
			</div>
			<div id="BSet(const BSet& other) :)">
				<h3>inline BSet(const BSet&amp; other) : _def();</h3>
				<p>构造一个集合，并添加other中的所有元素。</p>
			</div>
			<div id="~BSet()">
				<h3>inline ~BSet();</h3>
				<p>析构此集合。</p>
			</div>
			<div id="size() const">
				<h3>inline int size() const;</h3>
			</div>
			<div id="capacity() const">
				<h3>inline int capacity() const;</h3>
			</div>
			<div id="empty() const">
				<h3>inline bool empty() const;</h3>
			</div>
			<div id="reset()">
				<h3>inline void reset();</h3>
				<p>清空所有元素，但不释放存储空间。此方法常用于多次重复使用容器时，减少内存操作提高效率。</p>
			</div>
			<div id="clear()">
				<h3>inline void clear();</h3>
				<p>清空此集合中的所有元素，同时释放掉存储空间。</p>
			</div>
			<div id="relax()">
				<h3>inline bool relax();</h3>
				<p>重新计算当前集合中元素的数量实际需要多少空间，若有多作的空间则将其释放。此方法用于节省空间。</p>
			</div>
			<div id="reserve(int)">
				<h3>inline bool reserve(int size);</h3>
				<p>分配size大小的空间，若当前元素个数小于size，则删除多余的元素。否则不改变现有的元素。</p>
			</div>
			<div id="check(int) const">
				<h3>inline bool check(int index) const;</h3>
			</div>
			<div id="contain(const UT&) const">
				<h3>inline bool contain(const UT&amp; value) const;</h3>
			</div>
			<div id="contain(const T&) const">
				<h3>inline bool contain(const T&amp; value) const;</h3>
			</div>
			<div id="find(const UT&) const">
				<h3>inline int find(const UT&amp; value) const;</h3>
			</div>
			<div id="find(const T&) const">
				<h3>inline int find(const T&amp; value) const;</h3>
			</div>
			<div id="first()">
				<h3>inline T&amp; first();</h3>
				<p>取得第一个元素的引用。</p>
			</div>
			<div id="first() const">
				<h3>inline const T&amp; first() const;</h3>
			</div>
			<div id="middle()">
				<h3>inline T&amp; middle();</h3>
				<p>取得中间位置的元素引用。</p>
			</div>
			<div id="middle() const">
				<h3>inline const T&amp; middle() const;</h3>
			</div>
			<div id="last()">
				<h3>inline T&amp; last();</h3>
				<p>取得最后一个元素的引用。</p>
			</div>
			<div id="last() const">
				<h3>inline const T&amp; last() const;</h3>
			</div>
			<div id="min()">
				<h3>inline T&amp; min();</h3>
				<p>取得最小的元素引用，此方法相当于first()，因为第一个元素就是最小的。</p>
			</div>
			<div id="min() const">
				<h3>inline const T&amp; min() const;</h3>
			</div>
			<div id="max()">
				<h3>inline T&amp; max();</h3>
				<p>取得最大的元素引用，此方法相当于last()，因为第一个元素就是最大的。</p>
			</div>
			<div id="max() const">
				<h3>inline const T&amp; max() const;</h3>
			</div>
			<div id="data()">
				<h3>inline T* data();</h3>
				<p>取得此集合的数据，可以用于改变元素，但请慎用，因为这会使得当前集合顺序失效。此方法常用于数据的读取，操作情况保证了读入的数据是有序的。</p>
			</div>
			<div id="data() const">
				<h3>inline const T* data() const;</h3>
			</div>
			<div id="data(int)">
				<h3>inline T* data(int index);</h3>
				<p>获得index位置元素的数据，可以修改元素，但请慎用。</p>
			</div>
			<div id="data(int) const">
				<h3>inline const T* data(int index) const;</h3>
			</div>
			<div id="at(int)">
				<h3>inline T&amp; at(int index);</h3>
				<p>获得index位置的元素引用。</p>
			</div>
			<div id="at(int) const">
				<h3>inline const T&amp; at(int index) const;</h3>
			</div>
			<div id="def()">
				<h3>inline T&amp; def();</h3>
				<p>获得默认值的引用。</p>
			</div>
			<div id="def() const">
				<h3>inline const T&amp; def() const;</h3>
			</div>
			<div id="insert(const UT&)">
				<h3>inline int insert(const UT&amp; value);</h3>
				<p>插入一个元素，并赋值为value。如果等于此值的元素已经存在则不进行操作，只返回其位置值。</p>
			</div>
			<div id="insert(const T&)">
				<h3>inline int insert(const T&amp; value);</h3>
				<p>插入一个元素，并赋值为value。如果等于此值的元素已经存在则不进行操作，只返回其位置值。</p>
			</div>
			<div id="insert(const UT*, int)">
				<h3>inline int insert(const UT* data, int size);</h3>
				<p>插入若干个元素，并依次赋值为data[i]。返回新元素的个数，其值可能小于size，因为插入的数据可能有重复。</p>
			</div>
			<div id="insert(const T*, int)">
				<h3>inline int insert(const T* data, int size);</h3>
				<p>插入若干个元素，并依次赋值为data[i]。返回新元素的个数，其值可能小于size，因为插入的数据可能有重复。</p>
			</div>
			<div id="insert(const BSet<UT>&)">
				<h3>inline int insert(const BSet&lt;UT&gt;&amp; other);</h3>
				<p>插入other中的所有元素，返回新元素个数，其值可能少于other的元素值，因为可能此集合中已经包含了部分元素。</p>
			</div>
			<div id="insert(const BSet&)">
				<h3>inline int insert(const BSet&amp; other);</h3>
				<p>插入other中的所有元素，返回新元素个数，其值可能少于other的元素值，因为可能此集合中已经包含了部分元素。</p>
			</div>
			<div id="remove(int,int)">
				<h3>inline bool remove(int pos, int count = 1);</h3>
				<p>删除此集合中的若干元素，pos指示开始位置，count表示删除的个数。</p>
			</div>
			<div id="remove(const UT&)">
				<h3>inline bool remove(const UT&amp; value);</h3>
				<p>寻找到等于value的元素，并将其删除。</p>
			</div>
			<div id="remove(const T&)">
				<h3>inline bool remove(const T&amp; value);</h3>
				<p>寻找到等于value的元素，并将其删除。</p>
			</div>
			<div id="remove(const UT*, int)">
				<h3>inline int remove(const UT* data, int size);</h3>
				<p>删除指定包含在指定数据中的所有元素，data指示数据位置，size指示数据个数。返回删除掉的元素个数。</p>
			</div>
			<div id="remove(const T*, int)">
				<h3>inline int remove(const T* data, int size);</h3>
				<p>删除指定包含在指定数据中的所有元素，data指示数据位置，size指示数据个数。返回删除掉的元素个数。</p>
			</div>
			<div id="remove(const BSet<UTk>&)">
				<h3>inline int remove(const BSet&lt;UTk&gt;&amp; other);</h3>
				<p>删除包含在other集合中的所有元素，返回删除掉的元素个数。</p>
			</div>
			<div id="remove(const BSet&)">
				<h3>inline int remove(const BSet&amp; other);</h3>
				<p>删除包含在other集合中的所有元素，返回删除掉的元素个数。</p>
			</div>
			<div id="operator()(int)">
				<h3>inline T&amp; operator()(int index);</h3>
				<p>取得index位置的元素的引用，此方法首先判断index是否有效，若无效则返回默认元素的引用。</p>
			</div>
			<div id="operator()(int) const">
				<h3>inline const T&amp; operator()(int index) const;</h3>
				<p>取得index位置的元素的常量引用，此方法首先判断index是否有效，若无效则返回默认元素的常量引用。</p>
			</div>
			<div id="operator[](int)">
				<h3>inline T&amp; operator[](int index);</h3>
				<p>取得index位置的元素引用，此方法不判断index是否有效，直接取值，所以要确保index有效，否则会导致内存访问错误。</p>
			</div>
			<div id="operator[](int) const">
				<h3>inline const T&amp; operator[](int index) const;</h3>
				<p>取得index位置的元素常量引用，此方法不判断index是否有效，直接取值，所以要确保index有效，否则会导致内存访问错误。</p>
			</div>
			<div id="operator = (const BSet<UT>&)">
				<h3>inline const BSet&amp; operator = (const BSet&lt;UT&gt;&amp; other);</h3>
				<p>清空所有元素，并插入other中的所有元素。</p>
			</div>
			<div id="operator = (const BSet&)">
				<h3>inline const BSet&amp; operator = (const BSet&amp; other);</h3>
				<p>清空所有元素，并插入other中的所有元素。</p>
			</div>
			<div id="operator << (const UT&)">
				<h3>inline BSet&amp; operator &lt;&lt; (const UT&amp; value);</h3>
				<p>向集合中插入一个元素，赋值为value。功能等同于insert(value)。</p>
			</div>
			<div id="operator << (const T&)">
				<h3>inline BSet&amp; operator &lt;&lt; (const T&amp; value);</h3>
				<p>向集合中插入一个元素，赋值为value。功能等同于insert(value)。</p>
			</div>
			<div id="operator << (const BSet<UT>&)">
				<h3>inline BSet&amp; operator &lt;&lt; (const BSet&lt;UT&gt;&amp; other);</h3>
				<p>向集合中插入other中的所有元素。功能等同于insert(other)。</p>
			</div>
			<div id="operator << (const BSet&)">
				<h3>inline BSet&amp; operator &lt;&lt; (const BSet&amp; other);</h3>
				<p>向集合中插入other中的所有元素。功能等同于insert(other)。</p>
			</div>
			<div id="operator < (const UT&) const">
				<h3>inline int operator &lt; (const UT&amp; value) const;</h3>
				<p>取得小于且仅小于value的元素的位置。</p>
			</div>
			<div id="operator <= (const UT&) const">
				<h3>inline int operator &lt;= (const UT&amp; value) const;</h3>
				<p>取得小于且仅小于或者等于value的元素的位置。</p>
			</div>
			<div id="operator > (const UT&) const">
				<h3>inline int operator &gt; (const UT&amp; value) const;</h3>
				<p>取得大于且仅大于value的元素的位置。</p>
			</div>
			<div id="operator >= (const UT&) const">
				<h3>inline int operator &gt;= (const UT&amp; value) const;</h3>
				<p>取得大于且仅大于或者等于value的元素的位置。</p>
			</div>
		</div>
	</body>
</html>